{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"softmax.ipynb","provenance":[],"collapsed_sections":[]},"language_info":{"name":"python"},"kernelspec":{"name":"python3","display_name":"Python 3"}},"cells":[{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"HOI8hK6IMjWS","executionInfo":{"status":"ok","timestamp":1618484597732,"user_tz":-480,"elapsed":24231,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"1202674a-ece2-4b1d-f40c-e183a7b27939"},"source":["# This mounts your Google Drive to the Colab VM.\n","from google.colab import drive\n","drive.mount('/content/drive', force_remount=True)\n","\n","# Enter the foldername in your Drive where you have saved the unzipped\n","# assignment folder, e.g. 'cs231n/assignments/assignment1/'\n","FOLDERNAME = 'cs231n/assignments/assignment1/'\n","assert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n","\n","# Now that we've mounted your Drive, this ensures that\n","# the Python interpreter of the Colab VM can load\n","# python files from within it.\n","import sys\n","sys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n","\n","# This downloads the CIFAR-10 dataset to your Drive\n","# if it doesn't already exist.\n","%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n","!bash get_datasets.sh\n","%cd /content/drive/My\\ Drive/$FOLDERNAME"],"execution_count":2,"outputs":[{"output_type":"stream","text":["Mounted at /content/drive\n","/content/drive/My Drive/cs231n/assignments/assignment1/cs231n/datasets\n","/content/drive/My Drive/cs231n/assignments/assignment1\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-title"],"id":"SBpw_YF0MjWZ"},"source":["# Softmax exercise\n","\n","*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n","\n","This exercise is analogous to the SVM exercise. You will:\n","\n","- implement a fully-vectorized **loss function** for the Softmax classifier\n","- implement the fully-vectorized expression for its **analytic gradient**\n","- **check your implementation** with numerical gradient\n","- use a validation set to **tune the learning rate and regularization** strength\n","- **optimize** the loss function with **SGD**\n","- **visualize** the final learned weights\n"]},{"cell_type":"code","metadata":{"tags":["pdf-ignore"],"id":"iRZWAIu4MjWa","executionInfo":{"status":"ok","timestamp":1618484657153,"user_tz":-480,"elapsed":2630,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}}},"source":["import random\n","import numpy as np\n","from cs231n.data_utils import load_CIFAR10\n","import matplotlib.pyplot as plt\n","\n","%matplotlib inline\n","plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n","plt.rcParams['image.interpolation'] = 'nearest'\n","plt.rcParams['image.cmap'] = 'gray'\n","\n","# for auto-reloading extenrnal modules\n","# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n","%load_ext autoreload\n","%autoreload 2"],"execution_count":3,"outputs":[]},{"cell_type":"code","metadata":{"tags":["pdf-ignore"],"colab":{"base_uri":"https://localhost:8080/"},"id":"y87Elo5cMjWa","executionInfo":{"status":"ok","timestamp":1618484831039,"user_tz":-480,"elapsed":3397,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"b173dc37-d35e-40c5-c0e2-dfc902565f35"},"source":["def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n","    \"\"\"\n","    Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n","    it for the linear classifier. These are the same steps as we used for the\n","    SVM, but condensed to a single function.  \n","    \"\"\"\n","    # Load the raw CIFAR-10 data\n","    cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n","    \n","    # Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n","    try:\n","       del X_train, y_train\n","       del X_test, y_test\n","       print('Clear previously loaded data.')\n","    except:\n","       pass\n","\n","    X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n","    \n","    # subsample the data\n","    mask = list(range(num_training, num_training + num_validation))\n","    X_val = X_train[mask]\n","    y_val = y_train[mask]\n","    mask = list(range(num_training))\n","    X_train = X_train[mask]\n","    y_train = y_train[mask]\n","    mask = list(range(num_test))\n","    X_test = X_test[mask]\n","    y_test = y_test[mask]\n","    mask = np.random.choice(num_training, num_dev, replace=False)\n","    X_dev = X_train[mask]\n","    y_dev = y_train[mask]\n","    \n","    # Preprocessing: reshape the image data into rows\n","    X_train = np.reshape(X_train, (X_train.shape[0], -1))\n","    X_val = np.reshape(X_val, (X_val.shape[0], -1))\n","    X_test = np.reshape(X_test, (X_test.shape[0], -1))\n","    X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n","    \n","    # Normalize the data: subtract the mean image\n","    mean_image = np.mean(X_train, axis = 0)\n","    X_train -= mean_image\n","    X_val -= mean_image\n","    X_test -= mean_image\n","    X_dev -= mean_image\n","    \n","    # add bias dimension and transform into columns\n","    X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n","    X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n","    X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n","    X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n","    \n","    return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n","\n","\n","# Invoke the above function to get our data.\n","X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n","print('Train data shape: ', X_train.shape)\n","print('Train labels shape: ', y_train.shape)\n","print('Validation data shape: ', X_val.shape)\n","print('Validation labels shape: ', y_val.shape)\n","print('Test data shape: ', X_test.shape)\n","print('Test labels shape: ', y_test.shape)\n","print('dev data shape: ', X_dev.shape)\n","print('dev labels shape: ', y_dev.shape)"],"execution_count":5,"outputs":[{"output_type":"stream","text":["Train data shape:  (49000, 3073)\n","Train labels shape:  (49000,)\n","Validation data shape:  (1000, 3073)\n","Validation labels shape:  (1000,)\n","Test data shape:  (1000, 3073)\n","Test labels shape:  (1000,)\n","dev data shape:  (500, 3073)\n","dev labels shape:  (500,)\n","(49000, 3073)\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"id":"YgQ7u6qqMjWb"},"source":["## Softmax Classifier\n","\n","Your code for this section will all be written inside `cs231n/classifiers/softmax.py`.\n"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"6xwBh0k-MjWb","executionInfo":{"status":"ok","timestamp":1618488364754,"user_tz":-480,"elapsed":1081,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"3942eb6a-1dbb-4e07-cf4f-8ddba4b5abc6"},"source":["# First implement the naive softmax loss function with nested loops.\n","# Open the file cs231n/classifiers/softmax.py and implement the\n","# softmax_loss_naive function.\n","\n","from cs231n.classifiers.softmax import softmax_loss_naive\n","import time\n","\n","# Generate a random softmax weight matrix and use it to compute the loss.\n","W = np.random.randn(3073, 10) * 0.0001\n","loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n","\n","# As a rough sanity check, our loss should be something close to -log(0.1).\n","print('loss: %f' % loss)\n","print('sanity check: %f' % (-np.log(0.1)))"],"execution_count":15,"outputs":[{"output_type":"stream","text":["loss: 2.291129\n","sanity check: 2.302585\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"sAG16N19MjWc"},"source":["**Inline Question 1**\n","\n","Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n","\n","$\\color{blue}{\\textit Your Answer:}$ *Fill this in* \n","\n"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"mRCbOa-MMjWc","executionInfo":{"status":"ok","timestamp":1618493963002,"user_tz":-480,"elapsed":8304,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"dcc3491f-5f62-40ee-d9f3-f28ec43285c9"},"source":["# Complete the implementation of softmax_loss_naive and implement a (naive)\n","# version of the gradient that uses nested loops.\n","loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n","\n","# As we did for the SVM, use numeric gradient checking as a debugging tool.\n","# The numeric gradient should be close to the analytic gradient.\n","from cs231n.gradient_check import grad_check_sparse\n","f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n","grad_numerical = grad_check_sparse(f, W, grad, 10)\n","\n","# similar to SVM case, do another gradient check with regularization\n","loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n","f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n","grad_numerical = grad_check_sparse(f, W, grad, 10)"],"execution_count":28,"outputs":[{"output_type":"stream","text":["numerical: -0.999113 analytic: -0.999113, relative error: 7.049308e-09\n","numerical: -0.734583 analytic: -0.734583, relative error: 7.503838e-08\n","numerical: 0.493359 analytic: 0.493359, relative error: 4.480099e-08\n","numerical: -0.541710 analytic: -0.541710, relative error: 9.426016e-08\n","numerical: -1.848805 analytic: -1.848805, relative error: 6.043485e-08\n","numerical: 0.117822 analytic: 0.117822, relative error: 1.000651e-06\n","numerical: 0.304317 analytic: 0.304317, relative error: 3.051737e-07\n","numerical: -0.331916 analytic: -0.331916, relative error: 9.958876e-08\n","numerical: 0.784276 analytic: 0.784276, relative error: 4.589204e-08\n","numerical: 0.655278 analytic: 0.655278, relative error: 1.938655e-08\n","numerical: -0.581021 analytic: -0.581021, relative error: 4.630895e-08\n","numerical: -1.810903 analytic: -1.810903, relative error: 3.404851e-10\n","numerical: -0.423592 analytic: -0.423592, relative error: 3.182056e-08\n","numerical: 3.046421 analytic: 3.046421, relative error: 2.161215e-09\n","numerical: -0.024363 analytic: -0.024363, relative error: 1.209417e-06\n","numerical: 2.257947 analytic: 2.257947, relative error: 1.749787e-08\n","numerical: -2.205087 analytic: -2.205087, relative error: 4.442313e-09\n","numerical: -0.794071 analytic: -0.794071, relative error: 8.983617e-08\n","numerical: 4.248587 analytic: 4.248587, relative error: 4.970263e-09\n","numerical: 1.584368 analytic: 1.584368, relative error: 4.732818e-08\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"pu-zfsxvMjWd","executionInfo":{"status":"ok","timestamp":1618495205320,"user_tz":-480,"elapsed":3457,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"ba177138-7679-43d7-c788-80b5716e76eb"},"source":["# Now that we have a naive implementation of the softmax loss function and its gradient,\n","# implement a vectorized version in softmax_loss_vectorized.\n","# The two versions should compute the same results, but the vectorized version should be\n","# much faster.\n","tic = time.time()\n","loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n","toc = time.time()\n","print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n","\n","from cs231n.classifiers.softmax import softmax_loss_vectorized\n","tic = time.time()\n","loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n","toc = time.time()\n","print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n","\n","# As we did for the SVM, we use the Frobenius norm to compare the two versions\n","# of the gradient.\n","grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n","print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n","print('Gradient difference: %f' % grad_difference)"],"execution_count":33,"outputs":[{"output_type":"stream","text":["naive loss: 2.291129e+00 computed in 0.165424s\n","vectorized loss: 2.291129e+00 computed in 0.013638s\n","Loss difference: 0.000000\n","Gradient difference: 0.000000\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"tuning","tags":["code"],"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1618496228762,"user_tz":-480,"elapsed":87271,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"1295f81d-5470-402f-8e52-e4c844f8d1ec"},"source":["# Use the validation set to tune hyperparameters (regularization strength and\n","# learning rate). You should experiment with different ranges for the learning\n","# rates and regularization strengths; if you are careful you should be able to\n","# get a classification accuracy of over 0.35 on the validation set.\n","\n","from cs231n.classifiers import Softmax\n","results = {}\n","best_val = -1\n","best_softmax = None\n","\n","################################################################################\n","# TODO:                                                                        #\n","# Use the validation set to set the learning rate and regularization strength. #\n","# This should be identical to the validation that you did for the SVM; save    #\n","# the best trained softmax classifer in best_softmax.                          #\n","################################################################################\n","\n","# Provided as a reference. You may or may not want to change these hyperparameters\n","learning_rates = [1e-7, 5e-7, 2e-6]\n","regularization_strengths = [1e3, 2.5e4, 5e4]\n","\n","# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","\n","for rate in learning_rates:\n","    for strength in regularization_strengths:\n","          softmax = Softmax()\n","          loss = softmax.train(X_train, y_train, learning_rate=rate, reg=strength,\n","                      num_iters=1500, verbose=False)\n","          y_train_pred = softmax.predict(X_train)\n","          training_accuracy = np.mean(y_train == y_train_pred)\n","          y_val_pred = softmax.predict(X_val)\n","          validation_accuracy = np.mean(y_val == y_val_pred)\n","          if validation_accuracy > best_val:\n","              best_val = validation_accuracy\n","              best_softmax = softmax\n","          results[(rate, strength)] = (training_accuracy, validation_accuracy)\n","\n","# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n","    \n","# Print out results.\n","for lr, reg in sorted(results):\n","    train_accuracy, val_accuracy = results[(lr, reg)]\n","    print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n","                lr, reg, train_accuracy, val_accuracy))\n","    \n","print('best validation accuracy achieved during cross-validation: %f' % best_val)"],"execution_count":36,"outputs":[{"output_type":"stream","text":["lr 1.000000e-07 reg 1.000000e+03 train accuracy: 0.264020 val accuracy: 0.283000\n","lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.329347 val accuracy: 0.338000\n","lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.308041 val accuracy: 0.327000\n","lr 5.000000e-07 reg 1.000000e+03 train accuracy: 0.390082 val accuracy: 0.377000\n","lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.324449 val accuracy: 0.332000\n","lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.306776 val accuracy: 0.318000\n","lr 2.000000e-06 reg 1.000000e+03 train accuracy: 0.388102 val accuracy: 0.397000\n","lr 2.000000e-06 reg 2.500000e+04 train accuracy: 0.308204 val accuracy: 0.314000\n","lr 2.000000e-06 reg 5.000000e+04 train accuracy: 0.258000 val accuracy: 0.282000\n","best validation accuracy achieved during cross-validation: 0.397000\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"test","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1618496256140,"user_tz":-480,"elapsed":1220,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"2220bd1c-b6af-4cbf-bebf-88ae671d97dd"},"source":["# evaluate on test set\n","# Evaluate the best softmax on test set\n","y_test_pred = best_softmax.predict(X_test)\n","test_accuracy = np.mean(y_test == y_test_pred)\n","print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))"],"execution_count":37,"outputs":[{"output_type":"stream","text":["softmax on raw pixels final test set accuracy: 0.379000\n"],"name":"stdout"}]},{"cell_type":"markdown","metadata":{"tags":["pdf-inline"],"id":"7VuKY8M6MjWe"},"source":["**Inline Question 2** - *True or False*\n","\n","Suppose the overall training loss is defined as the sum of the per-datapoint loss over all training examples. It is possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n","\n","$\\color{blue}{\\textit Your Answer:}$\n","\n","\n","$\\color{blue}{\\textit Your Explanation:}$\n","\n"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":380},"id":"Tj0a5VLGMjWe","executionInfo":{"status":"ok","timestamp":1618496276910,"user_tz":-480,"elapsed":1535,"user":{"displayName":"Mingyu Yang","photoUrl":"","userId":"04100620278597188865"}},"outputId":"ea0ddee5-8719-4901-e549-c43606d056bf"},"source":["# Visualize the learned weights for each class\n","w = best_softmax.W[:-1,:] # strip out the bias\n","w = w.reshape(32, 32, 3, 10)\n","\n","w_min, w_max = np.min(w), np.max(w)\n","\n","classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n","for i in range(10):\n","    plt.subplot(2, 5, i + 1)\n","    \n","    # Rescale the weights to be between 0 and 255\n","    wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n","    plt.imshow(wimg.astype('uint8'))\n","    plt.axis('off')\n","    plt.title(classes[i])"],"execution_count":38,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 720x576 with 10 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"code","metadata":{"id":"0XwsF_5iMjWe"},"source":[""],"execution_count":null,"outputs":[]}]}